package pool;

import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPoolDemo3 {
    //四种线程池的简单使用
    /*
        线程池的创建：
            1.newFixedThreadPool()
            2.newCachedThreadPool()
            3.newSingleThreadExecutor()
            4.newScheduledThreadPool()
    */
    public static void main(String[] args) {//创建定长线程池，支持定时及周期性任务执行
        //创建线程池对象
        //提交任务的优先级：核心线程 >> 阻塞队列 >> 非核心线程
        //消费者任务优先级：核心线程 >> 非核心线程 >> 阻塞队列
        //只有当阻塞队列放不下时，才会创建非核心线程
        ExecutorService threadPool = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 10; i++) {
            threadPool.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName());
                }
            });
        }
        threadPool.shutdown();
    }

    //定长线程池，支持定时及周期性任务执行
    public static void main3(String[] args) {//创建定长线程池，支持周期性的任务调度
        ExecutorService threadPool = Executors.newScheduledThreadPool(5);

        for (int i = 0; i < 10; i++) {
            threadPool.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName());
                    try {
                        Thread.sleep(new Random().nextInt(1000)+100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
        //关闭线程池
        if (!threadPool.isShutdown()){
            threadPool.shutdown();
        }
    }
    //缓存线程池，没有阻塞队列
    public static void main2(String[] args) {//创建缓存线程池,无限大，可以创建线程，可以缓存线程，可以执行任务，可以回收线程，可以重复使用线程
        ExecutorService threadPool = Executors.newCachedThreadPool();//缓存线程池
        for (int i = 0; i < 10; i++) {
            threadPool.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName());
                }
            });
        }
        threadPool.shutdown();


    }
    //单线程池,可以实现线程安全，单线程线程池
    /*
        底层返回值是一个单线程的线程池对象，线程池中的线程数固定为1，线程数固定为1，空闲时存活时间为0
        是由阻塞队列来存储任务的，执行任务，执行完一个任务，再执行下一个任务
     */
    public static void main1(String[] args) {
        //创建线程池对象
        ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();//单线程池
        for (int i = 0; i < 10; i++) {
            singleThreadExecutor.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName());
                }
            });
        }
        singleThreadExecutor.shutdown();
        /*
            运行结果为：10个
            pool-1-thread-1

        */



    }
}
